a = 10          # 全局变量
def num():
    a = 6       # 局部变量
    print(a)
# num()
# print(a)  # a会是几？
def num1():
    global a        # global关键字，可以引用全局变量，进行修改
    a = 6
    return a

# print(num1())
# print(a)        # 6
# 函数内部可以调用其他函数
def get_log():
    print("app starting ...")
def kill_server():
    print("kill ..")
def get_app():          # 在这个函数里面，调用了其他两个写好函数
    get_log()
    kill_server()
# get_app()
# 自己调用自己
def tell_stroy():
    print("从前有座山")
    print("山上有座庙")
    print("庙里有个老和尚")
    print("在给小和尚讲故事")
    print("讲的是什么呢？")
    tell_stroy()        # 自己调用了自己
# tell_stroy()
# 就像是循环一样。但是递归不同，递归给一个出口
"""
while True:
    print("从前有座山")
    print("山上有座庙")
    print("庙里有个老和尚")
    print("在给小和尚讲故事")
    print("讲的是什么呢？")
"""
def text1(i):
    if i==10:
        return 10
    else:
        return i+text1(i+1)
# r = text1(1)
# print(r) # 1+2+3+4+5+6+7+8+9+10
# 计算x开始以内的和
def sum2(x):
    if x >1:
        value = x + sum2(x-1)
    else:
        value = 1
    return value
# print(sum2(10))# 10 +9+8+7+6+5+4+3+2+1
# 匿名函数
# print(lambda x, y: x + y) #<function <lambda> at 0x00000245A198F790>
# print(lambda x, y: x + y()) # 函数地址
f = lambda x,y:x+y
# print(f) # <function <lambda> at 0x00000285CD58F820>
# print(f(1,2)) # 相当于调用这个函数，加上参数，实际参数
# 匿名函数和内置函数使用
salarics={
    'xiao':300000,
    'xiaolong2':3000,
    'long1':1000,
}
# print(sorted(salarics)) # 这样排序，拿到的是key值比较
"""
字符串排序的话，比较的是ascii码值
a 97  b 98 c 99 .... z
A 65  B 66 C 67 ....
"""
print(max(salarics)) # 拿到的是最大的key值，按照字母的ascii码值比对

def func(name):
    return salarics[name]
# 不使用匿名函数比对
# print(max(salarics,key=func)) # 这个是可以不用写括号的

# 使用匿名函数比对
# print(max(salarics,key=lambda name:salarics[name]))

# 比较薪资，返回的是人名
# print(sorted(salarics, key=lambda name: salarics[name], reverse=True))
"""
sorted：原地排序，不会改变原来的数据内容，跟sort是不一样的
reverse：降序返回，默认这个参数是False。Flase是升序
"""

#根据员工表中的薪资进行排序
# 下面是列表套字典
s = [
    {'name':'龙仔','性别':'男','薪资':3000,'职位':'打工仔'},
    {'name':'曹賊','性别':'男','薪资':9000,'职位':'总经理'},
    {'name':'浩仔','性别':'男','薪资':8000,'职位':'副经理'},
    {'name':'雷子','性别':'男','薪资':5000,'职位':'督导'},
]
# _ = sorted(s,key=lambda s:s['薪资'],reverse=True)
# print(_)

# 闭包函数
"""
闭包最少要有两个函数来实现
外函数嵌套子函数，外函数返回的是子函数的地址值
"""
def outer():        # 外函数
    print("外面的函数正在运行")  # 打印语句
    def inner():    # 内函数
        print("里面的函数正在运行")  # 打印语句
    return inner            # 返回的是内函数的地址值，没有加括号不算调用
# o = outer()     # 把这个函数赋值对象
# o()         # 这个对象加上括号，调用闭包（原来没有的()，我给他补上）

# 这么调用也可以，但是不规范
# outer()()       # 原来差的()，给补上
# outer()()
"""
外面的函数正在运行
里面的函数正在运行
"""
# 写一个闭包，让数字自增长
def num_add():
    num = 0     # 局部变量
    def add():
        nonlocal num        # nonlocal 关键字  修改局部变量的值
        num+=1              # 每次调用的时候数字+1
        return num          # 子函数返回的是num值
    return add              # 外函数返回的是子函数的地址值

"""
n = num_add()       # 通过num_add赋值一个对象
print(n())  # 一直都是使用这个对象，加()来调用
print(n())
print(n())
print(n())
"""
"""
# 错误的使用方法。每一次都相当于是新的对象，所以不会自增
print(num_add()())
print(num_add()())
print(num_add()())
print(num_add()())
"""
#  装饰器
def run():
    print("跑步")
# run()
"""
1.在不改变run函数的调用方法
2.不改变内部结构
3.加上健身功能
"""
# 下面不是装饰器，因为改变了调用方式
def fitness():
    run()
    print("健身")
# fitness()
# 这个也不是装饰器，因为改变了内部结构。
"""
def run():
    print("跑步")     # 原来是没有跑步的，现在加上去了
    print("健身")
"""
# 原函数
def runs(name):
    print("==========")
    print(f"{name}正在运动")
    print("==========")
# 写了一个装饰器
def decorate(func):             # 待修饰的方法形参。形式参数
    def new_func(new_name):     # new_name就是原来函数里的形参，要带入过来
        print("我是被装饰器前面的代码")        # 打印语句
        func(new_name)                      # func(new_name)        调用参数，因为原来的方法有形参
        print("我是被装饰器后面的代码")        # 打印语句
    return new_func            # 外函数返回的是子函数的地址值
# d = decorate(runs)          # 调用装饰器，把要修饰的方法传进去
# d("小白")                 # 传入实参
"""
我是被装饰器前面的代码
==========
小白正在运动
==========
我是被装饰器后面的代码
"""
# 原来的方法。
def run_():
    print("跑步")
# 现在我要加上健身
def s(func):        # func 可以理解为是固定的形参，因为任何装饰器在写的时候，都需要传入原始的方法
    def luoji():
        func()      # 先调用原来的方法
        print("健身")     # 再加上print
    return luoji    # 返回子函数的地址值
# ss = s(run_)
# ss()
# ================简化引用==================
def info(func):
    def luoji(*args,**kwargs):
        print("大家好，现在开始自我介绍...")
        func(*args,**kwargs)
        print("自我介绍结束...")
    return luoji
@info       # 简化引用
def stu_info(*args,**kwargs):
    print(f"我来自：{args[0]}，今年{args[1]}岁")
# stu_info("辽宁沈阳",19)
"""
大家好，现在开始自我介绍...
我来自：辽宁沈阳，今年19岁
自我介绍结束...
"""
def aaa(func):      # 装饰器
    def bbb():
        print("为本次方法加上bbb")     # 装饰的功能
        print("为本次方法加上aaa")     # 装饰的功能
        func()      # 原来的方法 == ccc()方法本身
    return bbb
@aaa
def ccc():
    print("我是ccc")
# ccc()
"""
为本次方法加上bbb
为本次方法加上aaa
我是ccc
"""
"""
装饰器的格式：
def 函数a(func):
    def 函数b():
        。。。。可以加装饰的功能
        。。。。可以加装饰的功能
        func()      # 调用原来的函数
    return 函数b
@函数a
def 要装饰的方法():
    写自己的功能
要装饰的方法()
"""












































